package com.graduationproject.Util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 新增缓存（无过期时间）
     * @param key 键
     * @param value 内容
     * @return
     */
    public boolean set(String key, Object value) {
        if(value != null && ObjectUtils.isEmpty(value)) {
            throw new RuntimeException("value为空");
        }
        try{
            redisTemplate.opsForValue().set(key, value);
            return true;
        }catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 新增缓存（有过期时间）
     * @param key 键
     * @param value 内容
     * @param time 过期时间
     * @return
     */
    public boolean set(String key, Object value, long time) {
        if(value == null) {
            throw new RuntimeException("value为空");
        }
        try{
            if(time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                return true;
            }else return false;
        }catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取缓存
     * @param key
     * @return
     */
    public Object get(String key) {
        Object value = key == null ? null : redisTemplate.opsForValue().get(key);
        return value;
    }

    /**
     * 指定缓存失效时间
     * @param key   键
     * @param time  时间（秒）
     * @return
     */
    public boolean expire(String key, long time) {
        try{
            if(time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
                return true;
            }else return false;
        }catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传入一个或者多个
     * @return
     */
    public boolean del(String... key) {
        if(key != null && key.length > 0) {
            if(key.length == 1) {
                redisTemplate.delete(key[0]);
                return true;
            }else {
                redisTemplate.delete(Arrays.asList(key));
                return true;
            }
        }else return false;
    }

    /**
     * 根据key获取缓存过期时间
     * @param key
     * @return
     */
    public long getExpire(String key) {
        Long expire = redisTemplate.getExpire(key, TimeUnit.SECONDS);
        return expire;
    }

    /**
     * 缓存hash数据（无过期时间）
     * @param key  键
     * @param field  字段
     * @param value  值
     * @return
     */
    public boolean hset(String key, String field, Object value) {
        try{
            redisTemplate.opsForHash().put(key, field, value);
            return  true;
        }catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 缓存hash数据（有过期时间）
     * @param key 键
     * @param field 字段
     * @param value 值
     * @param time 时间
     * @return
     */
    public boolean hset(String key, String field, Object value, long time) {
        try{
            redisTemplate.opsForHash().put(key, field, value);
            if(time >= 0) {
                expire(key, time);
            }
            return  true;
        }catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键
     * @param item 值（可以有多个）
     */
    public  void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }
}

